package com.aspire.aimini.model.query;

import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;

import java.time.LocalDateTime;
import java.util.List;

/**
 * AI生成记录查询条件
 *
 * @author wangguiyou
 * @date 2024-12-19
 */
@Data
@EqualsAndHashCode(callSuper = true)
@Accessors(chain = true)
public class GenerationRecordQuery extends BaseQuery {

    /**
     * 用户ID
     */
    private Long userId;

    /**
     * 用户ID列表
     */
    private List<Long> userIds;

    /**
     * 服务类型
     */
    private String serviceType;

    /**
     * 服务类型列表
     */
    private List<String> serviceTypes;

    /**
     * AI配置ID
     */
    private Long aiConfigId;

    /**
     * AI配置ID列表
     */
    private List<Long> aiConfigIds;

    /**
     * 输入内容（模糊查询）
     */
    private String inputContent;

    /**
     * 输出内容（模糊查询）
     */
    private String outputContent;

    /**
     * 生成状态
     */
    private String status;

    /**
     * 生成状态列表
     */
    private List<String> statuses;

    /**
     * 错误信息（模糊查询）
     */
    private String errorMessage;

    /**
     * 最小响应时间（毫秒）
     */
    private Long minResponseTime;

    /**
     * 最大响应时间（毫秒）
     */
    private Long maxResponseTime;

    /**
     * 最小消耗成本
     */
    private Double minCost;

    /**
     * 最大消耗成本
     */
    private Double maxCost;

    /**
     * 最小输入Token数量
     */
    private Integer minInputTokens;

    /**
     * 最大输入Token数量
     */
    private Integer maxInputTokens;

    /**
     * 最小输出Token数量
     */
    private Integer minOutputTokens;

    /**
     * 最大输出Token数量
     */
    private Integer maxOutputTokens;

    /**
     * 最小总Token数量
     */
    private Integer minTotalTokens;

    /**
     * 最大总Token数量
     */
    private Integer maxTotalTokens;

    /**
     * 模型名称
     */
    private String model;

    /**
     * 模型名称列表
     */
    private List<String> models;

    /**
     * 服务提供商
     */
    private String provider;

    /**
     * 服务提供商列表
     */
    private List<String> providers;

    /**
     * 客户端IP
     */
    private String clientIp;

    /**
     * 客户端IP列表
     */
    private List<String> clientIps;

    /**
     * 用户代理（模糊查询）
     */
    private String userAgent;

    /**
     * 创建时间范围 - 开始
     */
    private LocalDateTime createTimeStart;

    /**
     * 创建时间范围 - 结束
     */
    private LocalDateTime createTimeEnd;

    /**
     * 更新时间范围 - 开始
     */
    private LocalDateTime updateTimeStart;

    /**
     * 更新时间范围 - 结束
     */
    private LocalDateTime updateTimeEnd;

    /**
     * 质量评分
     */
    private Integer qualityScore;

    /**
     * 最小质量评分
     */
    private Integer minQualityScore;

    /**
     * 最大质量评分
     */
    private Integer maxQualityScore;

    /**
     * 用户评价（模糊查询）
     */
    private String userFeedback;

    /**
     * 是否收藏
     */
    private Boolean isFavorite;

    /**
     * 最小使用次数
     */
    private Integer minUsageCount;

    /**
     * 最大使用次数
     */
    private Integer maxUsageCount;

    /**
     * 最后使用时间范围 - 开始
     */
    private LocalDateTime lastUsedTimeStart;

    /**
     * 最后使用时间范围 - 结束
     */
    private LocalDateTime lastUsedTimeEnd;

    /**
     * 是否有错误信息
     */
    private Boolean hasErrorMessage;

    /**
     * 是否有用户评价
     */
    private Boolean hasUserFeedback;

    /**
     * 是否有最后使用时间
     */
    private Boolean hasLastUsedTime;

    /**
     * 排除的记录ID列表
     */
    private List<Long> excludeIds;

    /**
     * 包含的记录ID列表
     */
    private List<Long> includeIds;

    /**
     * 是否只查询成功记录
     */
    private Boolean onlySuccess;

    /**
     * 是否只查询失败记录
     */
    private Boolean onlyFailed;

    /**
     * 是否只查询处理中记录
     */
    private Boolean onlyProcessing;

    /**
     * 是否只查询高质量记录（评分>=4）
     */
    private Boolean onlyHighQuality;

    /**
     * 是否只查询低质量记录（评分<=2）
     */
    private Boolean onlyLowQuality;

    /**
     * 是否只查询收藏记录
     */
    private Boolean onlyFavorites;

    /**
     * 是否只查询快速响应记录（响应时间<=3秒）
     */
    private Boolean onlyFastResponse;

    /**
     * 是否只查询慢响应记录（响应时间>=10秒）
     */
    private Boolean onlySlowResponse;

    /**
     * 是否只查询低成本记录（成本<=0.1元）
     */
    private Boolean onlyLowCost;

    /**
     * 是否只查询高成本记录（成本>=1元）
     */
    private Boolean onlyHighCost;

    /**
     * 是否只查询大Token记录（总Token>=1000）
     */
    private Boolean onlyLargeTokens;

    /**
     * 是否只查询小Token记录（总Token<=100）
     */
    private Boolean onlySmallTokens;

    /**
     * 是否只查询频繁使用记录（使用次数>=5）
     */
    private Boolean onlyFrequentlyUsed;

    /**
     * 是否只查询未使用记录（使用次数=0）
     */
    private Boolean onlyUnused;

    /**
     * 是否只查询今日记录
     */
    private Boolean onlyToday;

    /**
     * 是否只查询本周记录
     */
    private Boolean onlyThisWeek;

    /**
     * 是否只查询本月记录
     */
    private Boolean onlyThisMonth;

    /**
     * 是否只查询最近使用记录（最近7天有使用）
     */
    private Boolean onlyRecentlyUsed;

    /**
     * 是否只查询长期未使用记录（30天以上未使用）
     */
    private Boolean onlyLongUnused;

    /**
     * 最小Token使用效率（tokens/秒）
     */
    private Double minTokenEfficiency;

    /**
     * 最大Token使用效率（tokens/秒）
     */
    private Double maxTokenEfficiency;

    /**
     * 最小成本效率（元/token）
     */
    private Double minCostEfficiency;

    /**
     * 最大成本效率（元/token）
     */
    private Double maxCostEfficiency;

    /**
     * 检查是否有时间范围查询条件
     */
    public boolean hasTimeRangeCondition() {
        return createTimeStart != null || createTimeEnd != null ||
                updateTimeStart != null || updateTimeEnd != null ||
                lastUsedTimeStart != null || lastUsedTimeEnd != null;
    }

    /**
     * 检查是否有性能相关查询条件
     */
    public boolean hasPerformanceCondition() {
        return minResponseTime != null || maxResponseTime != null ||
                onlyFastResponse != null || onlySlowResponse != null ||
                minTokenEfficiency != null || maxTokenEfficiency != null;
    }

    /**
     * 检查是否有成本相关查询条件
     */
    public boolean hasCostCondition() {
        return minCost != null || maxCost != null ||
                onlyLowCost != null || onlyHighCost != null ||
                minCostEfficiency != null || maxCostEfficiency != null;
    }

    /**
     * 检查是否有Token相关查询条件
     */
    public boolean hasTokenCondition() {
        return minInputTokens != null || maxInputTokens != null ||
                minOutputTokens != null || maxOutputTokens != null ||
                minTotalTokens != null || maxTotalTokens != null ||
                onlyLargeTokens != null || onlySmallTokens != null;
    }

    /**
     * 检查是否有质量相关查询条件
     */
    public boolean hasQualityCondition() {
        return qualityScore != null || minQualityScore != null ||
                maxQualityScore != null || onlyHighQuality != null ||
                onlyLowQuality != null || hasUserFeedback != null;
    }

    /**
     * 检查是否有使用相关查询条件
     */
    public boolean hasUsageCondition() {
        return minUsageCount != null || maxUsageCount != null ||
                onlyFrequentlyUsed != null || onlyUnused != null ||
                onlyRecentlyUsed != null || onlyLongUnused != null ||
                hasLastUsedTime != null;
    }

    /**
     * 检查是否有状态相关查询条件
     */
    public boolean hasStatusCondition() {
        return status != null || statuses != null ||
                onlySuccess != null || onlyFailed != null ||
                onlyProcessing != null || hasErrorMessage != null;
    }

    /**
     * 检查是否有内容相关查询条件
     */
    public boolean hasContentCondition() {
        return inputContent != null || outputContent != null ||
                errorMessage != null || userFeedback != null;
    }

    /**
     * 获取默认排序字段
     */
    @Override
    public String getDefaultSortField() {
        return "createTime";
    }

    /**
     * 获取默认排序方向
     */
    @Override
    public String getDefaultSortDirection() {
        return "DESC";
    }

    /**
     * 获取允许的排序字段
     */
    @Override
    public List<String> getAllowedSortFields() {
        return List.of(
                "id", "userId", "serviceType", "aiConfigId", "status",
                "responseTime", "cost", "inputTokens", "outputTokens",
                "totalTokens", "model", "provider", "createTime",
                "updateTime", "qualityScore", "usageCount", "lastUsedTime");
    }
}